home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource3 / 195_01 / doctor3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-10-05  |  7.9 KB  |  376 lines
  1. /* [DOCTOR3.C of JUGPDS Vol.18]
  2. *****************************************************************
  3. *                                *
  4. *    Written by  Hakuo Katayose (JUG-CP/M No.179)        *
  5. *            49-114 Kawauchi-Sanjuunin-machi        *
  6. *            Sendai, Miyagi 980                          *
  7. *            Phone: 0222-61-3219                *
  8. *                                *
  9. *    Edited & tested by Y. Monma (JUG-C/M Disk Editor)       * 
  10. *                                *
  11. *****************************************************************
  12. */
  13.  
  14. /* DOCTOR3 - Disk Doctor for CP/M Plus */
  15.  
  16. #include "stdio.h"
  17.  
  18. #define UP        0x05    /* Screen_Edit mode Cursole_up        */
  19. #define DOWN        0x18    /*        --II--    Cursole_down    */
  20. #define LEFT        0x13    /*        --II--    Cursole_letf    */
  21. #define RIGHT        0x06    /*        --II--    Cursole_right    */
  22. #define ESC_CH        '@'    /* Special command sequence code    */
  23. #define ENDINPUT    'Z'    /* Screen_Edit mode exit        */
  24. #define ABORT        'X'    /* Screen_Edit mode exit with out WRite */
  25.  
  26. /*
  27.  ************************************************************************
  28.  *    HOME        Cursole Home Positioning            *
  29.  *    CLRS        Clear Screen and Cursole Home Positioning    *
  30.  *    POS(x,y)    Set Cursole position (x,y)            *
  31.  ************************************************************************
  32. */
  33. #define ESC        0x1b
  34. #define    HOME        bios(4,ESC); bios(4,'H')
  35. #define    CLRS        bios(4,ESC); bios(4,'E')
  36. #define    POS(x,y)    bios(4,ESC); bios(4,'Y'); bios(4,y+32); bios(4,x+32)
  37.  
  38.  
  39. /*
  40.  *    Global DATA defintion
  41.  */
  42.  
  43. unsigned    tpd, bpd, No_Of_Track, No_Of_Sector, No_Of_Block, Block_Length;
  44.  
  45. /*
  46.  *    CP/M DPB (disk parameter block) definition
  47.  */
  48.  
  49. struct    dpb {
  50.     int    spt;        /* logical sector per track */
  51.     char    bsh,        /* block shift factor       */
  52.         blm,        /* block mask            */
  53.         exm;        /* extent mask            */
  54.     int    dsm,        /* disk storage (record)    */
  55.         drm;        /* total directory entry - 1*/
  56.     char    al0,al1;    /* allocation bit mask        */
  57.     int    cks;        /* size of directory check  */
  58.     int    off;        /* offset (system track)    */
  59.     char    psh,phm;
  60. };
  61.  
  62. /*
  63.  *    CP/M DPH (disk parameter header) definition
  64.  */
  65.  
  66.  
  67. struct    dph {
  68.     char    *xltp;        /* logical to physical trans  */
  69.     char    dmy1[9];    /* system use            */
  70.     char    mf;        /* Media flag            */
  71.     struct dpb    *dpbp;    /* pointer for DPB        */
  72.     char    *csvp,        /* pointer for check_size   */
  73.         *alvp;        /* pointer for allocation   */
  74.     char    *dirbcb, *dtabcb, *hash, hbank;
  75. };
  76.  
  77. struct    _biospb {
  78.     char        BIOS_NO;
  79.     char        A_REG;
  80.     unsigned    BC_REG;
  81.     unsigned    DE_REG;
  82.     unsigned    HL_REG;
  83. } biospb;
  84.  
  85. #define    max(x,y)    (((x)>(y))?(x):(y))
  86. #define    min(x,y)    (((x)<(y))?(x):(y))
  87.  
  88. struct    dph    *DPH;
  89. struct    dpb    *DPB;
  90.  
  91.  
  92. int        bn, bufcnt, es;
  93. char        vflag, logflag, blkflag;
  94. char        queflag, *quep;
  95.  
  96. char        *hexdigit;
  97.  
  98. main()
  99. {
  100.     char    *p, c, comnd, buf[2048], w[128], *wp;
  101.     int    d, i, j, v, len, t, s, n, sc;
  102.  
  103.     hexdigit = "0123456789ABCDEFabcdef";
  104.     queflag = 0;
  105.     vflag = 0;
  106.     logflag = 1;
  107.     blkflag = 0;
  108.     bn = 0;
  109.     s = 1;
  110.     p = buf;
  111.     CLRS;
  112.     POS(0,0); printf("Disk:"); d = toupper(bios(3,0)) - 'A';
  113.     t = seldisk(d);
  114.     while (GetSector(d,t,s,p) == 0) {
  115. loopd:        POS(0,4);
  116.         Display(p+128*es);
  117.         c = getchr();
  118.         switch ((comnd = tolower(c))) {
  119.         case 'a' :
  120.             Modify(t, s, p+128*es, comnd, p);
  121.             break;
  122.         case 'b' :
  123.             POS(57,0);    scanf("%d", &bn);
  124.             if (bn < 0 || bn > DPB->dsm)
  125.                 break;
  126.             blkflag = (blkflag) ? 0 : 1;
  127.             logflag = 1;
  128.             sc = bn * ( DPB->blm + 1);
  129.             t  = sc / DPB->spt;
  130.             s  = sc % DPB->spt + 1;
  131.             break;
  132.         case 'c' :
  133.             setmem(p+es*128, 128, 0);
  134.             PutSector(t, s, p);
  135.             break;
  136.         case 'd' :
  137.             POS(5, 0); d = toupper(bios(3, 0)) - 'A';
  138.             seldisk(d);
  139.             break;
  140.         case 'e' :
  141.             exit();
  142.         case 'h' :
  143.             Modify(t, s, p+128*es, comnd, p);
  144.             break;
  145.         case 'i' :
  146.             setmem(p+es*128, 128, 0x0e5);
  147.             PutSector(t, s, p);
  148.             break;
  149.         case 'l' :
  150.             logflag = logflag ? 0 : 1;
  151.             seldisk(d);
  152.             break;
  153.         case 'q' :
  154.             queflag = queflag ? 0 : 1;
  155.             quep = "++++++++++++++++";
  156.             goto loopd;
  157.         case 't' :
  158.             POS(16, 0);    scanf("%d", &t);
  159.             break;
  160.         case 's' :
  161.             POS(37, 0);    scanf("%d", &s);
  162.             break;
  163.         case '+' :
  164.         case ';' :
  165.             if ( ++s > DPB->spt ) {s = 1; t++;}
  166.             break;
  167.         case '-' :
  168.         case '=' :
  169.             if ( --s < 1 ) {s = DPB->spt; t--;}
  170.             break;
  171.         case '>' :
  172.         case '.' :
  173.             t++;
  174.             break;
  175.         case '<' :
  176.         case ',' :
  177.             t--;
  178.             break;
  179.         default :
  180.             goto loopd;
  181.         }
  182.         s = max(1, s);
  183.         s = min(DPB->spt, s);
  184.         t = max(0, t);
  185.         t = min(tpd + DPB->off*logflag, t);
  186.         bn = (t * DPB->spt + s -1)/(DPB->blm + 1);
  187.     }
  188.     POS(0, 23);
  189. }
  190.  
  191.  
  192. GetSector(d, t, s, p)
  193. char    *p;
  194. {
  195.     int    bn;
  196.  
  197.     es = (s-1) % (DPB->phm + 1);
  198.     bn = (t * DPB->spt + s -1)/(DPB->blm+1);
  199.     POS(16, 0);    printf("%4d      ", t);
  200.     POS(37, 0);    printf("%3d      ", s);
  201.     POS(56, 0);    printf("%4d      ", bn);
  202.     BIOS_CALL(10, t+logflag*DPB->off, 0, 0);    /* set Track No  */
  203.     BIOS_CALL(11, (s-1)/(DPB->phm+1)+1, 0, 0);    /* set Sector No */
  204.     BIOS_CALL(12, p, 0, 0);                /* set DMA       */
  205.     BIOS_CALL(28, 0, 0, 1);
  206.     BIOS_CALL(13, 0, 0, 0);
  207.     return 0;
  208. }
  209.  
  210.  
  211. PutSector(t, s, p)
  212. int     t, s;
  213. char    *p;
  214. {
  215.     BIOS_CALL(10,t+logflag*DPB->off, 0, 0);        /* set track no */
  216.     BIOS_CALL(11,(s-1)/(DPB->phm+1)+1, 0, 0);    /* set Sector No */
  217.     BIOS_CALL(12, p, 0, 0);                /* set dma      */
  218.     BIOS_CALL(28, 0, 0, 1);
  219.     BIOS_CALL(14, 1, 0, 0);
  220. }
  221.  
  222.  
  223. getchr()
  224. {
  225.     if (queflag) {
  226.         if (*(quep+1) == '\0')
  227.             queflag = 0;
  228.         return *quep++;
  229.         }
  230.     return bios(3, 0);
  231. }
  232.  
  233.  
  234. Modify(t, s, p, mode, bp)
  235. char    *p, *bp, mode;
  236. {
  237.     int    j, x, y, c, c1, end_flag;
  238.  
  239.     j = 0;
  240.     x = 0;    y = 0;
  241.  
  242.     POS(0, 12);
  243.     printf("                                                  ");
  244.     POS(0, 12);
  245.     printf("%s mode Modify-Data :", mode == 'a' ? "Ascii" : "Hexdec");
  246.     end_flag = 0;
  247.     while (!end_flag) {
  248.         POS(x+x, (mode == 'a' ? y+y+5 : y+y+4));
  249.         switch (c = bios(3, 0)) {
  250.             case UP :
  251.                 if (y)
  252.                     y--;
  253.                 break;
  254.             case DOWN :
  255.                 if (y<4)
  256.                     y++;
  257.                 break;
  258.             case LEFT :
  259.                 if (x)
  260.                     x--;
  261.                 else if (y) {
  262.                     x = 31;
  263.                     y--;
  264.                     }
  265.                 break;
  266.             case RIGHT :
  267.                 if (x < 31)
  268.                     x++;
  269.                 else if (y < 3) {
  270.                     x = 0;
  271.                     y++;
  272.                     }
  273.                 break;
  274.             default :
  275.                 if (c == ESC_CH) {
  276.                     if ((c = toupper(bios(3, 0))) == ENDINPUT) {
  277.                         end_flag = 1;
  278.                         break;
  279.                         }
  280.                     else if (c == ABORT) {
  281.                         end_flag = 1;
  282.                         break;
  283.                         }
  284.                     }
  285.                 if (mode == 'h') {
  286.                     c1 = bios(3, 0);
  287.                     c1 = toupper(c1);
  288.                     c  = toupper(c);
  289.                     if ((c1 = index_(hexdigit, c1)) >= 0
  290.                      && (c = index_(hexdigit, c)) >= 0) {
  291.                         *(p + j) = c*16+c1;
  292.                     }
  293.                 }
  294.                 else
  295.                     *(p + j) = c;
  296.                 POS(0, 4);
  297.                 Display(p);
  298.                 if (x < 31)
  299.                     x++;
  300.                 else if (y < 3) {
  301.                     x = 0;
  302.                     y++;
  303.                     }
  304.             }
  305.         j = (y << 5) + x;
  306.         }
  307.     if (c != ABORT)
  308.         PutSector(t, s, bp);
  309.     POS(0, 12);
  310.     printf("                                                  ");
  311. }
  312.  
  313.  
  314. seldisk(d)
  315. int d;
  316. {
  317.     unsigned    x,y,z;
  318.  
  319. /*    bios(27, 0);
  320. */
  321.     DPH = BIOS_CALL(9, d, 0, 0);        /* select disk  */
  322.     DPB = DPH->dpbp;
  323.     x = DPB->blm+1;    
  324.     y = DPB->dsm;
  325.     z = DPB->spt;
  326.     No_Of_Sector  = z;
  327.     No_Of_Track   = (x * y + z - 1)/ z + DPB->off;
  328.     No_Of_Block   = y + 1;
  329.     Block_Length  = x * 128;
  330.  
  331.  
  332.     POS(0,21);
  333.      printf("Track_No :=%6d       Sector_No :=%6d       Block_No   :=%6d\n",
  334.                  No_Of_Track, No_Of_Sector, No_Of_Block);
  335.     printf("Offset   :=%6u       Directry  :=%6u       Block_size :=%6d",
  336.             DPB->off, DPB->drm+1, Block_Length);
  337.     POS(0,0);
  338.     printf("Disk:     Track:              Sector:              Block:");
  339.     POS(5 ,0);    putchar(d+'A');
  340.     POS(0 ,2);    printf(logflag ? "(  Log" : "( Phys");
  341.     POS(6 ,2);    printf("ical-CP/M-Sector )");
  342.     tpd = No_Of_Track-1;
  343.     bpd = No_Of_Block-1;
  344.     return DPB->off*logflag;
  345. }
  346.  
  347.  
  348. setmem(p, l, d)
  349. char *p, d;
  350. int  l;
  351. {
  352.     while (l--) *p++ = d;
  353. }
  354.  
  355.  
  356. index_(s, c)
  357. char *s, c;
  358. {
  359.     char *p;
  360.  
  361.     for (p = s; *s != c; s++)
  362.         if (!*s)
  363.             return -1;
  364.     return s-p;
  365. }
  366.  
  367.  
  368. BIOS_CALL(fn, bcreg, dereg, areg)
  369. {
  370.     biospb.BIOS_NO = fn;
  371.      biospb.BC_REG  = bcreg;
  372.      biospb.DE_REG  = dereg;
  373.      biospb.A_REG  = areg;
  374.     return bdos(50, &biospb);
  375. }
  376.